import { defineStore } from 'pinia'
import { ref, computed } from 'vue'
import request from '@/utils/request'
import { getToken, getUserInfo } from '@/utils/auth'
import { useUserStore } from '@/stores/user'
import { ElMessage } from 'element-plus'

export const useChatStore = defineStore('chat', () => {
    const ws = ref(null)
    const chatList = ref([])
    const messages = ref({}) // 存储所有聊天记录 {userId: messages[]}
    const wsConnected = ref(false)
    
    // 计算总未读消息数
    const totalUnreadCount = computed(() => {
        return chatList.value.reduce((total, chat) => total + (chat.unreadCount || 0), 0)
    })

    // 初始化聊天列表和WebSocket
    const initChatList = async () => {
        try {
            // 检查token
            const token = getToken()
            if (!token) {
                console.warn('缺少认证Token，无法初始化聊天')
                chatList.value = []
                return { records: [], total: 0 }
            }
            
            // 检查用户信息
            const userInfo = getUserInfo()
            if (!userInfo?.id) {
                console.warn('用户信息不完整，尝试刷新用户信息')
                try {
                    const userStore = useUserStore()
                    await userStore.getInfo()
                } catch (error) {
                    console.error('刷新用户信息失败:', error)
                    chatList.value = []
                    return { records: [], total: 0 }
                }
            }
            
            // 获取聊天列表
            try {
                const result = await fetchChatList({ pageNum: 1, pageSize: 50 })
                console.log('聊天列表初始化完成, 共有聊天:', result.total || 0)
                return result
            } catch (error) {
                console.error('获取聊天列表失败但继续执行:', error)
                // 继续初始化WebSocket，避免因聊天列表获取失败而影响聊天功能
                chatList.value = []
                return { records: [], total: 0 }
            }
        } catch (error) {
            console.error('初始化聊天列表失败:', error)
            chatList.value = []
            return { records: [], total: 0 }
        }
    }

    // 连接WebSocket
    const connectWebSocket = async () => {
        // 获取token（不依赖userStore的登录状态）
        const token = getToken()
        if (!token) {
            console.warn('缺少认证Token，无法连接WebSocket')
            return false
        }
        
        // 获取用户信息并尝试多种可能的ID字段
        let userInfo = getUserInfo()
        let userId = userInfo?.id || userInfo?.userId || userInfo?.user_id || userInfo?.ID
        
        // 如果本地用户信息无效，尝试从API获取
        if (!userId) {
            console.warn('本地用户信息中缺少用户ID，尝试从API获取')
            try {
                const userStore = useUserStore()
                const userData = await userStore.getInfo()
                console.log('API返回的用户数据:', userData)
                
                // 从多个可能的位置尝试获取用户ID
                if (userData) {
                    // 1. 检查user对象中的各种ID字段命名
                    if (userData.user) {
                        userId = userData.user.id || userData.user.userId || 
                                userData.user.user_id || userData.user.ID || 
                                userData.user.userid
                        
                        // 输出user对象的所有键，帮助调试
                        console.log('用户对象的所有字段:', Object.keys(userData.user))
                    }
                    
                    // 2. 检查响应根级别的各种ID字段
                    if (!userId) {
                        userId = userData.userId || userData.user_id || 
                                userData.id || userData.ID || userData.userid
                    }
                    
                    // 3. 如果响应中包含用户名等信息，可以作为临时标识
                    if (!userId && userData.user && userData.user.username) {
                        console.log('使用username作为临时ID:', userData.user.username)
                        userId = `user_${userData.user.username}`
                    }
                    
                    if (userId) {
                        console.log('成功获取用户ID:', userId)
                        
                        // 保存获取到的ID到本地用户信息
                        if (userInfo) {
                            userInfo.id = userId
                            setUserInfo(userInfo)
                        } else if (userData.user) {
                            userData.user.id = userId
                            setUserInfo(userData.user)
                        }
                    } else {
                        console.error('无法从API响应中提取用户ID，响应数据:', userData)
                    }
                }
            } catch (error) {
                console.error('刷新用户信息失败:', error)
            }
        }
        
        if (!userId) {
            // 如果仍然无法获取用户ID，使用生成的临时ID
            userId = 'temp_' + new Date().getTime()
            console.warn('使用临时生成的用户ID:', userId)
            
            // 提示用户可能需要重新登录
            ElMessage.warning('无法获取您的用户信息，将使用临时ID。部分功能可能受限，建议重新登录。')
        }
        
        try {
            console.log('开始WebSocket连接, 用户ID:', userId)
            await initWebSocket(userId, token)
            return true
        } catch (error) {
            console.error('WebSocket连接失败:', error)
            return false
        }
    }

    // 初始化WebSocket连接
    const initWebSocket = async (userId, token) => {
        if (!token || !userId) {
            console.error('WebSocket连接需要userId和token')
            return Promise.reject('缺少用户ID或token')
        }
        
        // 关闭之前的连接
        closeWebSocket()
        
        return new Promise((resolve, reject) => {
            try {
                // 获取WebSocket URL
                let wsProtocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:'
                
                // 从环境变量或当前主机获取WebSocket主机
                let wsHost = import.meta.env.VITE_WS_HOST
                if (!wsHost) {
                    // 如果没有指定WS_HOST，则根据当前主机推断
                    if (window.location.host.includes('localhost')) {
                        // 开发环境，使用后端地址
                        wsHost = 'localhost:8080'
                    } else {
                        // 生产环境，使用当前主机
                        wsHost = window.location.host
                    }
                }
                
                // 构建WebSocket URL
                const wsUrl = `${wsProtocol}//${wsHost}/websocket/${userId}?token=${encodeURIComponent(token)}`
                
                console.log('尝试连接WebSocket:', wsUrl.replace(/token=.*/, 'token=***'))
                ws.value = new WebSocket(wsUrl)
                
                let connectionTimeout = setTimeout(() => {
                    if (ws.value && ws.value.readyState !== WebSocket.OPEN) {
                        console.error('WebSocket连接超时')
                        wsConnected.value = false
                        reject(new Error('WebSocket连接超时'))
                        
                        try {
                            ws.value.close()
                        } catch (e) {
                            console.error('关闭超时WebSocket连接失败:', e)
                        }
                    }
                }, 10000) // 10秒超时
                
                ws.value.onopen = () => {
                    console.log('WebSocket连接成功')
                    wsConnected.value = true
                    clearTimeout(connectionTimeout)
                    
                    // 获取用户ID用于心跳
                    const userInfo = getUserInfo()
                    const currentUserId = userInfo?.id || 0
                    
                    // 发送一个心跳消息，完全匹配后端预期格式
                    try {
                        ws.value.send(JSON.stringify({ 
                            type: 'ping',
                            // 以下是后端WebSocketServer.onMessage方法所需字段
                            toUserId: currentUserId,  // 必需字段
                            fromUserId: currentUserId, // 添加发送者ID
                            content: 'ping',  // 必需字段
                            messageType: 'ping'  // 可选，默认为"1"
                        }))
                    } catch (e) {
                        console.warn('发送初始心跳失败:', e)
                    }
                    
                    // 设置定期心跳
                    const heartbeatInterval = setInterval(() => {
                        if (ws.value && ws.value.readyState === WebSocket.OPEN) {
                            try {
                                // 获取最新的用户ID
                                const userInfo = getUserInfo()
                                const currentUserId = userInfo?.id || 0
                                
                                ws.value.send(JSON.stringify({ 
                                    type: 'ping',
                                    // 以下是后端WebSocketServer.onMessage方法所需字段
                                    toUserId: currentUserId,  // 必需字段
                                    fromUserId: currentUserId, // 添加发送者ID
                                    content: 'ping',  // 必需字段
                                    messageType: 'ping'  // 可选，默认为"1"
                                }))
                            } catch (e) {
                                console.warn('心跳发送失败:', e)
                                clearInterval(heartbeatInterval)
                            }
                        } else {
                            console.warn('WebSocket已关闭，停止心跳')
                            clearInterval(heartbeatInterval)
                        }
                    }, 30000) // 30秒发送一次心跳
                    
                    resolve(true)
                }
                
                ws.value.onmessage = (event) => {
                    try {
                        const message = JSON.parse(event.data)
                        console.log('收到消息:', message)
                        
                        // 处理特殊消息类型
                        if (message.type === 'pong' || message.type === 'ping') {
                            console.log('收到心跳响应')
                            return
                        }
                        
                        handleMessage(message)
                    } catch (error) {
                        console.error('消息解析错误:', error, event.data)
                    }
                }
                
                ws.value.onerror = (error) => {
                    console.error('WebSocket错误:', error)
                    wsConnected.value = false
                    clearTimeout(connectionTimeout)
                    reject(error)
                }
                
                ws.value.onclose = (event) => {
                    console.log(`WebSocket连接关闭: 代码=${event.code}, 原因=${event.reason}`)
                    wsConnected.value = false
                    clearTimeout(connectionTimeout)
                    
                    // 如果不是正常关闭，尝试重连
                    if (event.code !== 1000 && event.code !== 1001) {
                        // 使用指数退避算法进行重连
                        const maxRetryDelay = 30000 // 最大重试间隔30秒
                        const baseDelay = 1000 // 基础延迟1秒
                        let retryCount = 0
                        const maxRetryCount = 10 // 最大重试次数
                        
                        const reconnect = () => {
                            if (retryCount >= maxRetryCount) {
                                console.warn(`WebSocket重连失败，已达最大重试次数(${maxRetryCount})`)
                                ElMessage.warning('聊天服务连接失败，请刷新页面重试')
                                return
                            }
                            
                            // 计算指数退避延迟（1秒，2秒，4秒，8秒...最多30秒）
                            const delay = Math.min(baseDelay * Math.pow(2, retryCount), maxRetryDelay)
                            console.log(`WebSocket将在${delay/1000}秒后尝试第${retryCount+1}次重连`)
                            
                            setTimeout(() => {
                                console.log('尝试重新连接WebSocket...')
                                const userStore = useUserStore()
                                if (userStore.isLoggedIn) {
                                    initWebSocket(userId, token)
                                        .then(() => {
                                            console.log('WebSocket重连成功')
                                            // 重置重试计数
                                            retryCount = 0
                                        })
                                        .catch(err => {
                                            console.error('WebSocket重连失败:', err)
                                            retryCount++
                                            reconnect() // 继续重试
                                        })
                                }
                            }, delay)
                        }
                        
                        reconnect()
                    }
                }
            } catch (error) {
                console.error('创建WebSocket失败:', error)
                wsConnected.value = false
                reject(error)
            }
        })
    }
    
    // 关闭WebSocket连接
    const closeWebSocket = () => {
        if (ws.value && ws.value.readyState !== WebSocket.CLOSED) {
            try {
                ws.value.close()
            } catch (error) {
                console.error('关闭WebSocket错误:', error)
            }
        }
        wsConnected.value = false
    }

    // 获取聊天列表
    const fetchChatList = async (params = { pageNum: 1, pageSize: 20 }) => {
        const userStore = useUserStore()
        
        // 检查用户是否已登录
        if (!userStore.isLoggedIn || !userStore.userInfo?.id) {
            console.warn('未登录状态下尝试获取聊天列表')
            chatList.value = [] // 确保列表为空
            return { records: [], total: 0 }
        }
        
        try {
            console.log('开始获取聊天列表，参数:', params)
            
            // 添加重试机制
            let retryCount = 0
            const maxRetries = 2
            let lastError
            
            while (retryCount <= maxRetries) {
                try {
                    const res = await request({
                        url: '/chat/list',
                        method: 'get',
                        params,
                        // 确保请求超时有合理设置
                        timeout: 30000 // 增加到30秒
                    })
                    
                    if (res.code === 200) {
                        // 成功获取数据
                        console.log('聊天列表获取成功:', res.data)
                        chatList.value = res.data.records || []
                        return res.data
                    } else {
                        throw new Error(res.msg || '获取聊天列表失败')
                    }
                } catch (err) {
                    lastError = err
                    retryCount++
                    
                    if (err.response?.status === 401 || 
                        (err.message && err.message.includes('登录'))) {
                        // 未授权错误，不再重试
                        console.error('获取聊天列表失败: 未授权', err)
                        break
                    }
                    
                    if (retryCount <= maxRetries) {
                        console.warn(`获取聊天列表失败，尝试重试 (${retryCount}/${maxRetries})`)
                        await new Promise(r => setTimeout(r, 5000 * retryCount)) // 增加等待时间到5秒×重试次数
                    }
                }
            }
            
            // 如果重试后仍然失败
            console.error('获取聊天列表失败，已达最大重试次数:', lastError)
            
            // 返回空数据而不是抛出错误，避免UI崩溃
            chatList.value = []
            return { records: [], total: 0 }
        } catch (error) {
            console.error('获取聊天列表失败:', error)
            // 返回空数据而不是抛出错误
            chatList.value = []
            return { records: [], total: 0 }
        }
    }

    // 获取历史消息
    const fetchHistoryMessages = async (options) => {
        const { targetUserId, pageNum = 1, pageSize = 20, prepend = false } = typeof options === 'object' ? options : { targetUserId: options }
        const userStore = useUserStore()
        
        // 检查用户是否已登录
        if (!userStore.isLoggedIn || !userStore.userInfo?.id) {
            console.warn('未登录状态下尝试获取聊天历史记录')
            if (!messages.value[targetUserId]) {
                messages.value[targetUserId] = []
            }
            return { records: [], total: 0 }
        }
        
        try {
            console.log(`开始获取与${targetUserId}的聊天历史，页码:${pageNum}, 每页:${pageSize}`)
            
            // 添加重试机制
            let retryCount = 0
            const maxRetries = 2
            let lastError
            
            while (retryCount <= maxRetries) {
                try {
                    const res = await request({
                        url: `/chat/history/${targetUserId}`,
                        method: 'get',
                        params: { pageNum, pageSize },
                        timeout: 15000
                    })
                    
                    if (res.code === 200) {
                        console.log('聊天历史获取成功', res.data)
                        const records = res.data.records || []
                        
                        // 确保消息按时间排序（从旧到新）
                        records.sort((a, b) => new Date(a.sendTime) - new Date(b.sendTime))
                        
                        if (!messages.value[targetUserId]) {
                            messages.value[targetUserId] = []
                        }
                        
                        if (prepend) {
                            // 添加到前面（加载更早的消息）
                            messages.value[targetUserId] = [...records, ...messages.value[targetUserId]]
                        } else {
                            // 完全替换（首次加载）
                            messages.value[targetUserId] = records
                        }
                        
                        return res.data
                    } else {
                        throw new Error(res.msg || '获取历史消息失败')
                    }
                } catch (err) {
                    lastError = err
                    retryCount++
                    
                    if (err.response?.status === 401 || 
                        (err.message && err.message.includes('登录'))) {
                        // 未授权错误，不再重试
                        console.error('获取聊天历史失败: 未授权', err)
                        break
                    }
                    
                    if (retryCount <= maxRetries) {
                        console.warn(`获取聊天历史失败，尝试重试 (${retryCount}/${maxRetries})`)
                        await new Promise(r => setTimeout(r, 1000 * retryCount))
                    }
                }
            }
            
            // 如果重试后仍然失败，返回空数据
            console.error('获取聊天历史失败，已达最大重试次数:', lastError)
            
            // 返回空数据而不是抛出错误
            if (prepend) {
                // 如果是加载更多消息，保留现有消息
                return { records: [], total: messages.value[targetUserId]?.length || 0 }
            } else {
                // 如果是首次加载，初始化为空数组
                if (!messages.value[targetUserId]) {
                    messages.value[targetUserId] = []
                }
                return { records: [], total: 0 }
            }
        } catch (error) {
            console.error('获取历史消息失败:', error)
            
            // 返回空数据而不是抛出错误
            if (!messages.value[targetUserId]) {
                messages.value[targetUserId] = []
            }
            return { records: [], total: 0 }
        }
    }

    // 处理接收到的消息
    const handleMessage = (message) => {
        if (!message) return
        
        // 忽略心跳消息
        if (message.type === 'ping' || message.type === 'pong') {
            console.log('处理心跳消息')
            return
        }
        
        // 确保消息有必要的字段
        if (!message.messageId && !message.content) {
            console.warn('收到无效消息:', message)
            return
        }
        
        // 获取消息类型，默认为't'(文本)
        // 后端可能使用单字符类型: t=text, s=system, e=error, i=image
        const messageType = message.messageType || 't'
        
        // 获取当前用户ID
        const userStore = useUserStore()
        const currentUserId = userStore.userInfo?.id

        // 确认这是否是自己发送的消息
        const isSelfMessage = String(message.fromUserId) === String(currentUserId)
        
        // 关键修改：完全忽略来自自己的WebSocket消息，因为这些消息已经通过本地方式添加
        if (isSelfMessage && (messageType === 't' || messageType === 'i' || messageType === 'image')) {
            console.log('忽略来自WebSocket的自己发送的消息:', message)
            return
        }
        
        // 根据单字符消息类型处理
        switch (messageType) {
            case 't': // 文本消息
            case 'text':
                addMessage({...message, messageType: 't'})
                updateChatList({...message, messageType: 't'})
                break
            case 'i': // 图片消息
            case '2': // 数据库中的图片类型
            case 'image':
                addMessage({...message, messageType: 'i'})
                updateChatList({...message, messageType: 'i', content: '[图片]'})
                break
            case 's': // 系统消息
            case 'system':
                // 处理系统消息
                addSystemMessage({...message, messageType: 's'})
                break
            case 'e': // 错误消息
            case 'error':
                // 处理错误消息
                addErrorMessage({...message, messageType: 'e'})
                ElMessage.error(message.content || '发生错误')
                break
            case 'ping': // 心跳ping消息
            case 'pong': // 心跳pong响应
                console.log('处理心跳消息:', messageType)
                break
            default:
                // 未知类型作为普通文本处理
                addMessage({...message, messageType: 't'})
        }
    }

    // 添加消息到历史记录
    const addMessage = (message) => {
        // 确保消息类型不超出数据库限制(1字符)
        const safeMessage = {
            ...message,
            messageType: message.messageType === 'text' ? 't' : 
                          message.messageType === 'system' ? 's' :
                          message.messageType === 'error' ? 'e' :
                          message.messageType || 't'
        }
        
        // 确定聊天ID（如果是自己发送的消息，使用接收者ID作为聊天ID）
        const userStore = useUserStore()
        const currentUserId = userStore.userInfo?.id
        const isSelfMessage = String(safeMessage.fromUserId) === String(currentUserId)
        const chatId = isSelfMessage ? safeMessage.toUserId : safeMessage.fromUserId
        
        // 初始化消息数组
        if (!messages.value[chatId]) {
            messages.value[chatId] = []
        }
        
        // 检查是否已存在相同或相似的消息
        // 1. 检查messageId是否已存在
        const existsById = safeMessage.messageId && 
            messages.value[chatId].some(m => m.messageId === safeMessage.messageId)
        
        if (existsById) {
            console.log('忽略已存在的消息ID:', safeMessage.messageId)
            return
        }
        
        // 2. 如果是自己发送的消息，检查是否有相似的最近消息
        if (isSelfMessage) {
            // 检查最近的消息是否有内容和时间都相似的
            const recentMessages = messages.value[chatId].slice(-5)
            const hasSimilarMessage = recentMessages.some(m => {
                return m.content === safeMessage.content && 
                       String(m.fromUserId) === String(safeMessage.fromUserId) &&
                       Math.abs(new Date(m.sendTime) - new Date(safeMessage.sendTime)) < 10000
            })
            
            if (hasSimilarMessage && !message._isLocalSent) {
                console.log('忽略疑似重复的消息:', safeMessage)
                return
            }
        }
        
        // 添加消息
        messages.value[chatId].push(safeMessage)
    }
    
    // 添加系统消息
    const addSystemMessage = (message) => {
        // 使用单字符消息类型
        const safeMessage = {
            ...message,
            messageType: 's'
        }
        
        // 根据需要添加到特定聊天或全局通知
        if (safeMessage.toUserId) {
            if (!messages.value[safeMessage.toUserId]) {
                messages.value[safeMessage.toUserId] = []
            }
            messages.value[safeMessage.toUserId].push(safeMessage)
        }
    }
    
    // 添加错误消息
    const addErrorMessage = (message) => {
        // 使用单字符消息类型
        const safeMessage = {
            ...message,
            messageType: 'e'
        }
        
        // 同上，可以根据需要添加到特定聊天
        if (safeMessage.toUserId) {
            if (!messages.value[safeMessage.toUserId]) {
                messages.value[safeMessage.toUserId] = []
            }
            messages.value[safeMessage.toUserId].push(safeMessage)
        }
    }

    // 更新聊天列表
    const updateChatList = (message) => {
        const userStore = useUserStore()
        
        // 使用各种可能的字段获取当前用户ID
        const userInfo = userStore.userInfo || getUserInfo() || {}
        const currentUserId = userInfo.id || userInfo.userId || userInfo.user_id || (userStore.token ? 'logged_in_user' : null)
        
        if (!currentUserId) {
            console.warn('无法确定当前用户ID，聊天列表可能不准确')
            return
        }
        
        console.log('更新聊天列表，当前用户ID:', currentUserId, '消息:', message)
        
        // 确定目标用户ID（与当前用户聊天的对方）
        const targetUserId = String(message.fromUserId) === String(currentUserId) ? message.toUserId : message.fromUserId
        
        const existingChat = chatList.value.find(chat => String(chat.targetUserId) === String(targetUserId))
        
        if (existingChat) {
            // 更新最后一条消息
            existingChat.lastMessage = message.content
            existingChat.lastTime = message.sendTime
            
            // 只有收到的消息才增加未读数
            if (String(message.fromUserId) !== String(currentUserId)) {
                existingChat.unreadCount = (existingChat.unreadCount || 0) + 1
            }
            
            // 将更新的会话移到顶部
            const index = chatList.value.findIndex(chat => String(chat.targetUserId) === String(targetUserId))
            if (index > 0) {
                const chat = chatList.value.splice(index, 1)[0]
                chatList.value.unshift(chat)
            }
        } else {
            // 添加新的聊天项
            const newChat = {
                targetUserId,
                targetUserName: message.fromUserId === currentUserId ? '对方' : message.fromUserName || '用户',
                lastMessage: message.content,
                lastTime: message.sendTime,
                unreadCount: message.fromUserId !== currentUserId ? 1 : 0,
                avatar: '' // 默认头像，实际应该从后端获取
            }
            
            chatList.value.unshift(newChat)
        }
        
        // 触发未读消息更新事件
        window.dispatchEvent(new Event('unread-count-update'))
    }

    // 添加新聊天
    const addChat = async (chatInfo) => {
        const existingChat = chatList.value.find(chat => chat.targetUserId === chatInfo.targetUserId)
        
        if (existingChat) {
            // 更新现有聊天信息
            Object.assign(existingChat, {
                ...chatInfo,
                lastTime: chatInfo.lastTime || Date.now()
            })
            
            // 将聊天移到顶部
            const index = chatList.value.findIndex(chat => chat.targetUserId === chatInfo.targetUserId)
            if (index > 0) {
                const chat = chatList.value.splice(index, 1)[0]
                chatList.value.unshift(chat)
            }
        } else {
            // 添加新聊天
            chatList.value.unshift({
                ...chatInfo,
                lastTime: chatInfo.lastTime || Date.now()
            })
        }
        
        // 初始化消息数组
        if (!messages.value[chatInfo.targetUserId]) {
            messages.value[chatInfo.targetUserId] = []
        }
    }

    // 发送消息
    const sendMessage = async (options) => {
        const { targetUserId, content, messageType = 'text', houseId } = options
        
        // 确保messageType不超出数据库字段长度限制(极可能是只有1字符的字段)
        // 使用首字母作为类型标识: 't'=text, 's'=system, 'e'=error
        let safeMessageType;
        switch (messageType.toLowerCase().substring(0, 4)) {
            case 'text':
                safeMessageType = 't';
                break;
            case 'syst':
                safeMessageType = 's';
                break;
            case 'erro':
                safeMessageType = 'e';
                break;
            default:
                safeMessageType = 't'; // 默认为文本类型
        }
        
        // 如果WebSocket未连接，尝试重新连接
        if (!wsConnected.value) {
            console.warn('WebSocket未连接，尝试重新连接')
            try {
                const reconnected = await connectWebSocket()
                if (!reconnected) {
                    throw new Error('WebSocket连接失败，无法发送消息')
                }
            } catch (connError) {
                console.error('WebSocket重连失败:', connError)
                throw new Error('WebSocket未连接，请刷新页面重试')
            }
        }
        
        // 获取用户信息
        const userInfo = getUserInfo()
        
        // 尝试多种方式获取用户ID
        let fromUserId = userInfo?.id || userInfo?.userId || userInfo?.user_id || userInfo?.ID
        
        if (!fromUserId) {
            // 没有用户ID时使用生成的临时ID
            fromUserId = 'temp_user_' + new Date().getTime()
            console.warn('使用临时生成的发送者ID:', fromUserId)
            
            // 更新用户信息
            if (userInfo) {
                userInfo.id = fromUserId
                setUserInfo(userInfo)
            }
        }
        
        // 生成消息唯一ID
        const localMessageId = `local_${Date.now()}_${Math.random().toString(36).substring(2, 10)}`
        
        const message = {
            fromUserId: fromUserId,
            toUserId: targetUserId,
            content,
            messageType: safeMessageType, // 使用安全长度的消息类型
            sendTime: Date.now(),
            houseId,
            messageId: localMessageId, // 添加本地消息ID
            _isLocalSent: true // 标记为本地发送的消息
        }
        
        try {
            console.log('发送消息:', message)
            
            // 先添加到本地消息列表
            if (!messages.value[targetUserId]) {
                messages.value[targetUserId] = []
            }
            
            // 添加到本地消息列表
            addMessage({
                ...message,
                status: 'sending'
            })
            
            // 更新聊天列表
            updateChatList(message)
            
            // 然后通过WebSocket发送（复制一个不包含_isLocalSent标记的消息对象）
            const wsMessage = { ...message }
            delete wsMessage._isLocalSent // 删除本地标记
            ws.value.send(JSON.stringify(wsMessage))
            
            return message
        } catch (error) {
            console.error('发送消息失败:', error)
            
            // 添加错误消息
            addErrorMessage({
                content: '发送失败，请重试',
                toUserId: targetUserId,
                messageType: 'e', // 错误消息类型
                sendTime: Date.now()
            })
            
            throw error
        }
    }

    // 标记消息已读
    const markAsRead = async (targetUserId) => {
        if (!targetUserId) return
        
        try {
            const res = await request({
                url: `/chat/read/${targetUserId}`,
                method: 'put'
            })
            
            if (res.code === 200) {
                // 更新本地未读状态
                const chat = chatList.value.find(chat => chat.targetUserId === targetUserId)
                if (chat) {
                    chat.unreadCount = 0
                    
                    // 更新消息已读状态
                    if (messages.value[targetUserId]) {
                        messages.value[targetUserId].forEach(msg => {
                            if (msg.fromUserId === targetUserId) {
                                msg.readFlag = '1' // 标记为已读
                            }
                        })
                    }
                    
                    // 触发未读消息更新事件
                    window.dispatchEvent(new Event('unread-count-update'))
                }
                
                return true
            } else {
                throw new Error(res.msg || '标记已读失败')
            }
        } catch (error) {
            console.error('标记已读失败:', error)
            return false
        }
    }

    // 创建新的聊天对话
    const createChat = async (targetInfo) => {
        try {
            const { targetUserId, targetUserName, avatar, initialMessage } = targetInfo
            
            console.log('创建新聊天, 目标用户:', targetUserId, targetUserName)
            
            // 先检查现有聊天列表，如果已存在则直接返回
            const existingChat = chatList.value.find(chat => 
                chat.targetUserId === targetUserId || 
                chat.targetUserId === Number(targetUserId)
            )
            
            if (existingChat) {
                console.log('已存在与此用户的聊天', existingChat)
                return existingChat.id || existingChat.targetUserId
            }
            
            // 添加到本地聊天列表，不等待API响应
            const chatId = Date.now().toString() // 临时ID
            addChat({
                id: chatId,
                targetUserId: targetUserId,
                targetUserName: targetUserName || '经纪人',
                avatar: avatar || '/src/assets/images/default-avatar.png',
                lastMessage: initialMessage || '开始新对话',
                unreadCount: 0,
                lastTime: new Date().toISOString()
            })
            
            // 调用后端API创建聊天 (修复API路径)
            try {
                const response = await request({
                    url: '/chat/create', // 修正API路径
                    method: 'post',
                    data: {
                        targetUserId: targetUserId,
                    }
                })
                
                console.log('聊天创建API响应:', response)
                
                if (response && response.code === 200) {
                    console.log('聊天创建成功:', response.data)
                    return targetUserId
                } else {
                    console.warn('聊天创建返回非200状态:', response)
                    // 仍然返回targetUserId，因为我们已经在本地添加了聊天项
                    return targetUserId
                }
            } catch (apiError) {
                console.error('API创建聊天失败, 继续使用本地创建的聊天:', apiError)
                // 本地已添加聊天，返回目标用户ID
                return targetUserId
            }
        } catch (error) {
            console.error('创建聊天失败:', error)
            ElMessage.error('创建聊天失败，请重试')
            return null
        }
    }

    // 添加图片消息
    const addImageMessage = (options) => {
        const { toUserId, imageUrl, messageId } = options
        const userStore = useUserStore()
        const currentUserId = userStore.userInfo?.id
        
        if (!currentUserId) {
            console.error('无法发送图片消息，用户未登录')
            return false
        }
        
        // 创建图片消息对象
        const imageMessage = {
            messageId: messageId,
            fromUserId: currentUserId,
            toUserId: toUserId,
            content: imageUrl,
            messageType: 'image',
            sendTime: new Date().getTime(),
            imageUrl: imageUrl,
            imageType: 'chat',
            _isLocalSent: true // 标记为本地发送的消息
        }
        
        // 添加到消息列表
        addMessage(imageMessage)
        
        // 更新聊天列表中的最后消息
        updateChatLastMessage(toUserId, '[图片消息]', new Date().getTime())
        
        return true
    }

    return {
        ws,
        chatList,
        messages,
        wsConnected,
        totalUnreadCount,
        initChatList,
        connectWebSocket,
        initWebSocket,
        closeWebSocket,
        fetchChatList,
        fetchHistoryMessages,
        sendMessage,
        markAsRead,
        addChat,
        createChat,
        addImageMessage
    }
}) 